Evaluate reverse polish notation

Time: O(N); Space: O(N); medium

Evaluate the value of an arithmetic expression in Reverse Polish Notation.

Valid operators are +, -, *, /. Each operand may be an integer or another expression.

Notes:

  • Division between two integers should truncate toward zero.

  • The given RPN expression is always valid. That means the expression would always evaluate to a result and there won’t be any divide by zero operation.

Example 1:

Input: [“2”, “1”, “+”, “3”, “*”]

Output: 9

Explanation:

[“2”, “1”, “+”, “3”, “*”] -> ((2 + 1) * 3) -> 9

Example 2:

Input: [“4”, “13”, “5”, “/”, “+”]

Output: 6

Explanation:

[“4”, “13”, “5”, “/”, “+”] -> (4 + (13 / 5)) -> 6

Example 3:

Input: [“10”,“6”,“9”,“3”,“+”,“-11”,“”,”/”,””,“17”,“+”,“5”,“+”]

Output: 22

Explanation:

((10 * (6 / ((9 + 3) * -11))) + 17) + 5

= ((10 * (6 / (12 * -11))) + 17) + 5

= ((10 * (6 / -132)) + 17) + 5

= ((10 * 0) + 17) + 5

= (0 + 17) + 5

= 17 + 5

= 22

[1]:

import operator

class Solution1(object):
    def evalRPN(self, tokens) -> int:
        '''
        :type tokens: List[str]
        :rtype: int
        '''
        numerals = []
        operators = {"+": operator.add,
                     "-": operator.sub,
                     "*": operator.mul,
                     "/": operator.truediv
                    }
        for token in tokens:
            if token not in operators:
                numerals.append(int(token))
            else:
                y, x = numerals.pop(), numerals.pop()
                numerals.append(int(operators[token](x * 1.0, y)))
        return numerals.pop()

[2]:

s = Solution1()
tokens = ["2", "1", "+", "3", "*"]
assert s.evalRPN(tokens) == 9
tokens = ["4", "13", "5", "/", "+"]
assert s.evalRPN(tokens) == 6
tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
assert s.evalRPN(tokens) == 22